home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / getstr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  7.4 KB  |  282 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    getstr
  25. #undef    wgetstr
  26. #undef    mvgetstr
  27. #undef    mvwgetstr
  28. #undef    ungetstr
  29. #undef    wgetnstr
  30.  
  31. /* undefine any macros for functions called by this module if in debug mode */
  32. #ifdef PDCDEBUG
  33. #  undef    wrefresh
  34. #  undef    waddch
  35. #  undef    wgetch
  36. #  undef    cbreak
  37. #  undef    move
  38. #  undef    wmove
  39. #endif
  40.  
  41. #ifdef PDCDEBUG
  42. char *rcsid_getstr  = "$Id$";
  43. #endif
  44.  
  45. /*man-start*********************************************************************
  46.  
  47.   Name:                                                        getstr
  48.  
  49.   Synopsis:
  50.       int getstr(char *str);
  51.       int wgetstr(WINDOW *win, char *str);
  52.       int mvgetstr(int y, int x, char *str);
  53.       int mvwgetstr(WINDOW *win, int y, int x, char *str);
  54.       int wgetnstr(WINDOW *win, char *str, int ch);
  55.  
  56.   X/Open Description:
  57.      The effect of getstr() is as though a series of calls to getch()
  58.      were made, until a newline or carriage return is received. The
  59.      resulting value is placed in the area pointed to by *str. The user's
  60.      erase and kill characters are interpreted, as well as any special
  61.      keys; such as function keys.
  62.  
  63.      With wgetnstr(), a series of characters are read until a newline 
  64.      or carriage return is received.  The resulting value is placed 
  65.      in the area pointed to by the character pointer str.  The user's 
  66.      erase and kill characters are interpreted.  This differs from 
  67.      wgetstr() in that the number of characters read is limited by a passed
  68.      argument.
  69.  
  70.      NOTE: getstr(), mvgetstr() and mvwgetstr() are implemented as macros.
  71.  
  72.      WARNING:  There is no way to know how long the buffer passed to
  73.          wgetstr() is, so it is possible to overwrite wrong
  74.          memory or code!! This is the reason for the wgetnstr()
  75.          function :-)
  76.  
  77.   X/Open Return Value:
  78.      This functions return ERR on failure or any other value on success.
  79.  
  80.   X/Open Errors:
  81.      No errors are defined for this function.
  82.  
  83.   Portability                             X/Open    BSD    SYS V
  84.                                           Dec '88
  85.       getstr                                Y        Y       Y
  86.       wgtdch                                Y        Y       Y
  87.       mvgetstr                              Y        Y       Y
  88.       mvwgetstr                             Y        Y       Y
  89.       wgetnstr                              -        -      4.0
  90.  
  91. **man-end**********************************************************************/
  92.  
  93. #define MAXLINE 255
  94.  
  95. /***********************************************************************/
  96. int    getstr(char *str)
  97. /***********************************************************************/
  98. {
  99. #ifdef PDCDEBUG
  100.     if (trace_on) PDC_debug("getstr() - called\n");
  101. #endif
  102.  
  103.     if (stdscr == (WINDOW *)NULL)
  104.         return (ERR);
  105.     return(wgetnstr(stdscr,str,MAXLINE));
  106. }
  107. /***********************************************************************/
  108. int    wgetstr(WINDOW *win, char *str)
  109. /***********************************************************************/
  110. {
  111. #ifdef PDCDEBUG
  112.     if (trace_on) PDC_debug("wgetstr() - called\n");
  113. #endif
  114.  
  115.     if (win == (WINDOW *)NULL)
  116.         return (ERR);
  117.  
  118.     return(wgetnstr(win,str,MAXLINE));
  119. }
  120. /***********************************************************************/
  121. int    mvgetstr(int y, int x, char *str)
  122. /***********************************************************************/
  123. {
  124. #ifdef PDCDEBUG
  125.     if (trace_on) PDC_debug("mvgetstr() - called\n");
  126. #endif
  127.  
  128.     if (stdscr == (WINDOW *)NULL)
  129.         return (ERR);
  130.     if (move(y,x) == ERR)
  131.         return (ERR);
  132.     return(wgetnstr(stdscr,str,MAXLINE));
  133. }
  134. /***********************************************************************/
  135. int    mvwgetstr(WINDOW *win, int y, int x, char *str)
  136. /***********************************************************************/
  137. {
  138. #ifdef PDCDEBUG
  139.     if (trace_on) PDC_debug("mvwgetstr() - called\n");
  140. #endif
  141.  
  142.     if (win == (WINDOW *)NULL)
  143.         return (ERR);
  144.     if (wmove(win,y,x) == ERR)
  145.         return (ERR);
  146.     return(wgetnstr(win,str,MAXLINE));
  147. }
  148. /***********************************************************************/
  149. int    wgetnstr(WINDOW *win, char *str, int n)
  150. /***********************************************************************/
  151. {
  152.     int    ch, i, num,chars=0;
  153.     int    t = win->_tabsize;
  154.     int    x = win->_curx;
  155.     char*    p = str;
  156.     bool    stop = FALSE;
  157.     bool    oldecho;
  158.     bool    oldcbreak;
  159.     bool    oldnodelay;
  160.  
  161. #ifdef PDCDEBUG
  162.     if (trace_on) PDC_debug("wgetnstr() - called\n");
  163. #endif
  164.  
  165.     if (win == (WINDOW *)NULL)
  166.         return (ERR);
  167.  
  168. #ifdef UNIX
  169. /*
  170.  * this code is very dodgy
  171.  *
  172.     wrefresh(win);
  173.  
  174.     while ((*str = wgetch(win)) != ERR && *str != '\n')
  175.         ;
  176.     if (*str == ERR) {
  177.         *str = '\0';
  178.         waddstr(win,p);
  179.         return ERR;
  180.     }
  181.     *str = '\0';
  182.     waddstr(win,p);
  183.     return OK;
  184. */
  185. #else
  186.     oldcbreak = _cursvar.cbreak;    /* remember states     */
  187.     oldecho = _cursvar.echo;
  188.     oldnodelay = win->_nodelay;
  189.  
  190.     _cursvar.echo = FALSE;        /* we do echo ourselves    */
  191.     cbreak();        /* ensure each key is returned immediately */
  192.     win->_nodelay = FALSE;        /* don't return    -1     */
  193.  
  194.     wrefresh (win);
  195.  
  196.     while (!stop)
  197.     {
  198.     switch (ch = wgetch (win) & A_CHARTEXT)
  199.         {
  200.         case '\t':
  201.             ch = ' ';
  202.             num = t - (win->_curx - x)%t;
  203.             for (i=0; i<num; i++)
  204.                 {
  205.                 if (oldecho) 
  206.                     waddch (win, ch);
  207.                 *p++ = ch;
  208.                 }
  209.             chars += num;
  210.             break;
  211.  
  212.         case _ECHAR:  /* CTRL-H */     /* Delete character */
  213.             if (p > str)
  214.                 {
  215.                 if (oldecho) 
  216.                     waddstr (win, "\b \b");
  217.                 ch = *--p;
  218.                 if ((ch < ' ') && (oldecho))
  219.                     waddstr (win, "\b \b");
  220.                 }
  221.             chars--;
  222.             break;
  223.  
  224.         case _DLCHAR:  /* CTRL-U */     /* Delete line    */
  225.             while (p > str)
  226.                 {
  227.                 if (oldecho) 
  228.                     waddstr (win, "\b \b");
  229.                 ch = *--p;
  230.                 if ((ch < ' ') && (oldecho))
  231.                     waddstr (win, "\b \b");
  232.                 }
  233.             chars = 0;
  234.             break;
  235.  
  236.         case _DWCHAR: /* CTRL-W */    /* Delete word */
  237.             while ((p > str) && (*(p-1) == ' '))
  238.                 {
  239.                 if (oldecho) 
  240.                     waddstr (win, "\b \b");
  241.                 --p; /* remove space */
  242.                 chars--;
  243.                 }
  244.             while ((p > str) && (*(p-1) != ' '))
  245.                 {
  246.                 if (oldecho) 
  247.                     waddstr (win, "\b \b");
  248.                 ch = *--p;
  249.                 if ((ch < ' ') && (oldecho))
  250.                     waddstr (win, "\b \b");
  251.                 chars--;
  252.                 }
  253.             break;
  254.  
  255.         case '\n':
  256.         case '\r':
  257.             stop = TRUE;
  258.             if (oldecho) 
  259.                 waddch (win, '\n');
  260.             break;
  261.  
  262.         default:
  263.             *p++ = ch;
  264.             if (oldecho) 
  265.                 waddch (win, ch);
  266.             chars ++;
  267.             break;
  268.         }
  269.     wrefresh (win);
  270.     if (chars >= n)
  271.         break;
  272.     }
  273.     *p = '\0';
  274.  
  275.     _cursvar.echo = oldecho;    /* restore old settings    */
  276.     _cursvar.cbreak = oldcbreak;
  277.     win->_nodelay = oldnodelay;
  278.  
  279.     return (OK);
  280. #endif
  281. }
  282.